
export const arrayToLineEchart = (arr, xAxis, series) => {
  const xArr = []
  const values = []
  arr.forEach(element => {
    xArr.push(element[xAxis])
    values.push(element[series])
  })
  return { xAxis: xArr, series: values }
}

export const formatNumber = (num) => {
  // 如果num是整数，则直接返回
  if (Number.isInteger(num)) {
    return num
  }
  // 否则，使用toFixed方法保留两位小数，并转为字符串
  return Number(num.toFixed(2))
}

export const sumByKey = (array, key) => {
  // 使用reduce方法将数组转换为一个对象，其中key是唯一的，并且对应的值是累加后的对象
  const sumObject = array.reduce((accumulator, currentItem) => {
    // 如果当前key已经在累加器中，则累加当前项的其他字段
    if (accumulator[currentItem[key]]) {
      for (const prop in currentItem) {
        if (prop !== key && currentItem.hasOwnProperty(prop) && typeof currentItem[prop] === 'number') {
          accumulator[currentItem[key]][prop] = formatNumber((accumulator[currentItem[key]][prop] || 0) + currentItem[prop])
        }
      }
    } else {
      // 如果当前key不在累加器中，则添加当前项
      accumulator[currentItem[key]] = { ...currentItem }
    }
    return accumulator
  }, {})

  // 将累加后的对象转换回数组
  const resultArray = Object.values(sumObject)

  return resultArray
}

export const renameKeyInArray = (array, oldKey, newKey) => {
  return array.map(item => {
    // 创建一个新对象，其中可能包含旧键的值（如果存在）
    const newItem = { ...item }

    // 如果旧键存在于对象中，则将其值复制到新键，并删除旧键
    if (oldKey in newItem) {
      newItem[newKey] = newItem[oldKey]
      delete newItem[oldKey]
    }

    return newItem
  })
}

export const removeKeyFromArray = (array, keyToRemove) => {
  return array.map(item => {
    // 使用reduce方法创建一个新对象，其中不包含要移除的键
    const newItem = Object.keys(item).reduce((obj, key) => {
      if (key !== keyToRemove) {
        obj[key] = item[key]
      }
      return obj
    }, {})
    return newItem
  })
}

export const mergeArraysByKey = (array1, array2, key) => {
  if (array1.length == 0) { array1 = array2 }
  // 使用reduce方法将array2中的对象合并到array1中
  return array1.reduce((merged, item1) => {
    // 查找array2中是否有与item1具有相同键值的对象
    const item2 = array2.find(item2 => item2[key] === item1[key])

    // 如果有，则合并这两个对象（你可以选择合并策略，比如使用Object.assign或展开运算符）
    if (item2) {
      // 你可以根据需要选择合并策略，这里使用展开运算符合并对象
      merged.push({ ...item1, ...item2 })
    } else {
      // 如果没有，则直接添加item1到merged数组
      merged.push(item1)
    }

    // 返回更新后的merged数组以进行下一次迭代
    return merged
  }, []) // 初始值是一个空数组
}
